DIPGEOPR_03_12.knit

class: inverse,left, middle
background-image: url(background.png)
background-size: cover

##Módulo 3: Percepción remota, análisis masivo y Google Earth Engine.

### Introducción a Google Earth Engine y JavaScript

Gabriel Castro

mail gabriel.castro.b@pucv.cl</a>

.large[<a href="https://www.pucv.cl/uuaa/site/edic/base/port/labgrs.html">LabGRS</a> | Noviembre 2023]

---
class: center,middle
background-image: url(data:image/png;base64,#labgrs_logo.png)
background-size: 35%

---
## Contenidos.

.pull-left[
- ¿Que es Google Earth Engine? (GEE).

- Catálogo disponible.

- Ventajas y desventajas de GEE.

- Interfaz. 
 
- Introducción a JavaScript.

]

---
### ¿Que es Google earth engine?

> Google Earth Engine (GEE) es una plataforma basada en la nube para el análisis geoespacial a escala planetaria que ofrece las capacidades computacionales masivas de Google permitiendo abordar una variedad de problemas sociales de alto impacto como: deforestación, sequía, desastres, enfermedades, seguridad alimentaria, gestión del agua, monitoreo del clima y protección del medio ambiente (Gorelick et al., 2017).
>

<center>
![](data:image/png;base64,#cloud_computing.png)
<center>

<center>
![](data:image/png;base64,#logo_engine.jpg)
<center>

---
### Cloud computing.

- La computación en la nube (cloud computing) es la última revolución de la tecnología de información.

- Servidores dedicados al procesamiento masivo.

- Mejora en el flujo y tiempo de trabajo de forma excepcional.

<center>
Damitel Networks
<center>

---

### ¿Como funciona la API?

Google earth engine utiliza JavaScript como lenguaje de programación base, sin embargo podemos encontrar otras fuentes y plataformas diponibles.

---
### Catálogo disponible.

<center>
Google earth engine
<center>

---
### Ventajas y desventajas de GEE:
.pull-left[
* **Ventajas:**
    + Gran capacidad computacionales. 
    + Rapidez para realizar procesos complejos.
    + Amplios catálogos de información disponibles.
    + Interfaz amigable con el usuario basico. 
]

.pull-right[
* **Desventajas:**
    +  Requiere habilidades programaticas de JS para elaborar procesos más complejos.
    +  Capacidad almacenamiento es limitada (almacenamiento de Google Drive).
    +  Actualmente es gratuito, esto puede cambiar en el futuro.
    +  No es funcional para procesos dependientes del entorno (ejemplo: análisis de redes, drenaje, etc.)
]

<center>
www.Tenor.com
<enter>
---
### Interfaz.

**Code Editor:** nos dirige a la consola de engine para comenzar a trabajar.

**Documentation:** nos dirige a la pagina de GEE donde podemos encontrar una serie de manuales para el procesamiento de informacion satelital.

<center>
<img src="data:image/png;base64,#pantallazo.jpg" width="900px" HEIGHT = "400px"/>
<center>
---
### Editor de codigo:
<center>
<img src="data:image/png;base64,#codeeditor.jpg" width="1200px" HEIGHT = "550px"/>
<center>

---
### Dcocumentación:

--- 
---

### Introducción a JavaScript.
#### Tipos de variables:

**Strings:** Variables de texto o cadenas de caracteres, se utilizan las comillas simples o dobles para definir una cadena.

```java
// Usamos comillas simples o dobles para crear un string
var saludoString = 'Hola Mundo!!';
print( saludoString );
```
**Numeros:** En estas variables podemos almacenar números de distinta longitud y precisión.

```java
// Asignamos un número a una variable
var numero = 38;
print('El valor es:', numero);
```
---
**Listas:** Las listas las definimos con corchetes [ ]. En GEE son útiles para realizar selecciones de elementos y podemos almacenar números, caracteres u otros elementos.

```java
// Lista de números
var listDeNumeros = [0, 1, 1, 2, 3, 5];
print('Lista de Números:', listDeNumeros);
// Lista de strings.
var listDeStrings = ['a', 'b', 'c', 'd'];
print('Lista de strings:', listDeStrings);
// lista alfanumerica:
var lista3 = ["lunes", 34, "miercoles", 70];
print(lista3, "lista alfanum");
```

---
**Objetos (Diccionarios):**

Los objetos en JS hacen mención a una estructura que puede contener otros valores definidos por {}. Se utilizan claves para nombrar las variables contenidas en su interior las cuales pueden ser llamadas del forma individual o completa.

```java
// Usamos las llaves {} para hacer un diccionario de pares clave:valor
var object = {
  foo: 'bar',
  baz: 38,
  stuff: ['Algo', 'eso', 'otro más']
};
print('Diccionario:', object);
// Para acceder al valor de un diccionario se utiliza la clave y los corchetes [ ].
print('Imprime la clave foo:', object['foo']);
// También se puede acceder utilizando la notación con punto.
print('Print stuff:', object.stuff);
```

* Los objetos o diccionarios a diferencia de las listas, son objetos mas complejos dentro de Engine que permiten almacenar distintos tipos de variables en su interior

--
* En cuanto a su funcionalidad, los diccionarios cumplen el mismo propósito que los objetos, la diferencia está en la creación de un contenedor .ee

---

**Funciones:**

Las funciones son otra forma de mejorar la legibilidad y reutilización del código mediante el agrupamiento de operaciones.

+  Una función se define mediante _function()_ en nuestro script.
    
  +  Los nombres de las funciones comienzan con un caracter y tienen un par de paréntesis al final.
  
  +  Las funciones a menudo toman parámetros para definir su objetivo. Estos parámetros van dentro de      los paréntesis ().

```java
// Ejemplo de cómo se define una función
var funcion_saludo = function( nombre ) {
  var mensaje = '¡Hola ' + nombre + '! ¿Que hora es?';
  return mensaje;
};
// llamamos a la función con su parámetro.
print( funcion_saludo( 'Gabriel' ) );
```

+  El conjunto de declaraciones que componen la función van dentro de las llaves { }. finalmente, return indica            cuáles la salida de la función.
  
---
### Contenedores de GEE.

* Google earth engine posee contenedores especificos dentro de la API (.ee), los cuales permiten enviar dicha información para ser procesada en los servidores de la nube.

```java
// Definimos un string y lo agregamos al contenedor
var unString = 'procesando';
var eeString = ee.String(unString);
print('Donde estabas? ', eeString);

// 
```

* Trabajar con contenedores de engine asegura la optimización del trabajo y la velocidad del mismo. No utilizar los contenedores en nuestras variables puede derivar en los "cuellos de botella", los cuales ralentizan el procesamiento.

* **IMPORTANTE**: Los contenedores de Google earth engine se crean de manera diferente respecto a los objetos recién vistos. Estos poseen su estructura propia para ser creados, subseteados y procesados.

---
**Números:**

Utilice ee.Number() para crear un objeto número en el servidor. Por ejemplo, utilice el método JavaScript Math.E para crear un valor de la constante en el servidor:

```java
// Definimos un número en el servidor
var serverNumber = ee.Number(Math.E);
print('e = ', serverNumber);
```
Los métodos ee.String() y ee.Number() son constructores, y por tanto, tienen argumentos (y posiblemente otros parámetros). Un constructor comienza siempre con ee y retorna un objeto EE.

---
### Métodos en un objeto EE
Para operar con un objeto de EE vamos a utilizar los métodos que son provistos según la clase de objeto con la que pretendemos trabajar. Existen multiples metodos para operar dentro de GEE.

```java
// Utilice una función incorporada para realizar una operación en el número.
var logE = serverNumber.log();
print('log(e) = ', logE);
```
Listas: Podemos hacer una lista de JavaScript como un objeto ee.List en el servidor, ponemos un literal de JavaScript en un contenedor con números y cadenas.

```java
// Ejemplos de listas, secuencia por extensión
var eeList = ee.List([1, 2, 3, 4, 5]);
// Secuencia usando el método del objeto list
var secuencia = ee.List.sequence(1, 5);
print('Secuencia:', secuencia);
```
---
Podemos recuperar un elemento de la lista con el operador get(). Recuerde que esta lista solo existe en el servidor, EE nos permite acceder a esos objetos solo a través de sus métodos.

```java
// Usamos un método de ee.List para recuperar un valor
var valor = secuencia.get(2);
print('Valor en la posición 2:', valor);
```

Diccionarios: Podemos crear un diccionario en Earth Engine a partir de un objeto JavaScript, de la misma manera que lo hicimos con String, Number y List. La función ee.Dictionary se construye desde un objeto JavaScript.

```java
// Crear un diccionario en el servidor
var diccionario = ee.Dictionary({
  e: Math.E,
  pi: Math.PI,
  phi: (1 + Math.sqrt(5)) / 2
});
// Recuperar algunos valores desde el diccionario.
print('Euler:', diccionario.get('e'));
print('Pi:', diccionario.get('pi'));
print('Golden ratio:', diccionario.get('phi'));
// Recuperar todas las claves
print('Claves: ', diccionario.keys());
```

---

**Fechas**

Los objetos de tipo **ee.Date** nos permiten representar tiempo. Al igual que con los otros tipos de datos, NO se debe  confundir entre Date de JavaScript y el ee.Date de EE.

```java
// Definir una fecha en Earth Engine.
var fecha = ee.Date('2015-12-31');
print('Fecha:', fecha);
// Recuperar la fecha actual usando el método Date.now() de JavaScript.
var now = Date.now();
print('Milisegundos desde el 1 de Enero de 1970', now);
// Inicializar el objeto ee.Date
var eeNow = ee.Date(now);
print('Now:', eeNow);
```

* Los objetos fechas son muy importantes para filtrar las colecciones, utilizando la función filterDate().

---
### Recordatorios:

1) Cada vez que se desee declarar una variable se debe iniciar con la palabra var y para finalizar la 
lógica de una línea de código se debe finalizar con ;

2) Normalmente los ( ) hacen referencia a una función, sin embargo, también sirven para conformar un 
conjunto lógicos. Los [ ] sirven para construir arreglos o listas. Los { } normalmente sirven para 
 formas objetos; entiéndase como un objetico a los parámetros o opciones que se le pueden dar a un 
 gráfico, algoritmo o alguna función en específico. 
 
 3) Es una buena práctica poner muchos comentarios en tu código, para describir lo que estás tratando de hacer. También es bueno eliminar el código comentado que ya no hace nada. Ambas prácticas 
 mejorarán la legibilidad del código.

4) Los objetos y algoritmos implícitos en GEE a diferencia del lenguaje común de JavaScript se 
 caracterizan principalmente por usar al inicio .ee
 Todos los elementos que se remarcan en color violeta, hacen referencia a una función implícitas de 
 GEE. Los elementos remarcados en color verde hacen referencia a comentarios. Las líneas de 
 códigos remarcadas en color rojo hacen referencia a conjuntos de valores descritos dentro de un 
 metadato. Asimismo, sirven para asignar nombres, colores y configuraciones o parámetros de algunas 
 funciones o algoritmos. Los elementos que se muestran en color azul, hacen referencia a valores 
 numéricos.

---
### Bibliografía.

GORELICK, N., HANCHER, M., DIXON, M., ILYUSHCHENKO, S., THAU, D. y MOORE, R., 2017. Google Earth Engine: Planetary-scale geospatial analysis for everyone. Remote Sensing of Environment [en línea], vol. 202, pp. 18-27. ISSN 00344257. DOI 10.1016/j.rse.2017.06.031. Disponible en: https://doi.org/10.1016/j.rse.2017.06.031.

REDD, P.R.R. de E. por D. y D. de B. en C. y R.D., 2018. Introducción a Javascript para Google Earth Engine (GEE). Deutsche Gesellschaft für Internationale Zusammenarbeit (GIZ) [en línea], vol. 1. Disponible en: https://www.sica.int/download/?124837.

Google Earth Engine. (s. f.). https://earthengine.google.com/

Pérez, J. E. (2008). introducción JavaScript. Madrid, España.

---
class: inverse middle
![logo](data:image/png;base64,#LABGRS-PUCV.png)